{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-01T20:26:42.362722Z",
     "start_time": "2019-09-01T20:26:42.358348Z"
    }
   },
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"4\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-01T20:26:49.237397Z",
     "start_time": "2019-09-01T20:26:42.365918Z"
    }
   },
   "outputs": [],
   "source": [
    "%reload_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "import torch\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import style\n",
    "import seaborn as sns\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from joblib import load, dump\n",
    "from sklearn.metrics import cohen_kappa_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from fastai import *\n",
    "from fastai.vision import *\n",
    "from fastai.callbacks import *\n",
    "from torchvision import models as md\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "import re\n",
    "import math\n",
    "import collections\n",
    "from functools import partial\n",
    "from torch.utils import model_zoo\n",
    "from sklearn import metrics\n",
    "from collections import Counter\n",
    "import json\n",
    "from efficientnet_pytorch import EfficientNet\n",
    "from utils import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-01T20:26:49.293990Z",
     "start_time": "2019-09-01T20:26:49.245797Z"
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def seed_everything(seed):\n",
    "    random.seed(seed)\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed(seed)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "SEED = 2019\n",
    "seed_everything(SEED)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-01T20:26:49.344754Z",
     "start_time": "2019-09-01T20:26:49.301938Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0902_04-26-49\n"
     ]
    }
   ],
   "source": [
    "current_time = get_BJ_time()\n",
    "print(current_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reading data and Basic EDA(Exploratory Data Analysis)\n",
    "\n",
    "Here I am going to open the dataset with pandas, check distribution of labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-01T20:26:49.471739Z",
     "start_time": "2019-09-01T20:26:49.346492Z"
    }
   },
   "outputs": [],
   "source": [
    "df_2015 = pd.read_csv('../input/aptos-data-split/df_2015_raw_sigmaX10.csv')\n",
    "df_2019 = pd.read_csv('../input/aptos-data-split/df_2019_sigmaX10.csv')\n",
    "\n",
    "df = pd.concat([df_2015, df_2019]).reset_index(drop=True) # merge train val together\n",
    "df['is_valid'] = [False]*df_2015.shape[0] + [True]*df_2019.shape[0]\n",
    "\n",
    "test_df = pd.read_csv('../input/aptos2019-blindness-detection/sample_submission.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-02T14:35:57.296363Z",
     "start_time": "2019-09-02T14:35:57.261143Z"
    }
   },
   "outputs": [],
   "source": [
    "bs = 24 #smaller batch size is better for training, but may take longer\n",
    "sz = 256  # get model input size\n",
    "# sz = EfficientNet.get_image_size(model_name)  # get model input size\n",
    "tfms = get_transforms(do_flip=True,flip_vert=True, max_rotate=0, max_zoom=1.2, max_warp=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-02T14:36:02.464374Z",
     "start_time": "2019-09-02T14:35:57.968532Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ImageDataBunch;\n",
       "\n",
       "Train: LabelList (35126 items)\n",
       "x: ImageList\n",
       "Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256)\n",
       "y: FloatList\n",
       "0.0,0.0,0.0,0.0,0.0\n",
       "Path: .;\n",
       "\n",
       "Valid: LabelList (3662 items)\n",
       "x: ImageList\n",
       "Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256)\n",
       "y: FloatList\n",
       "0.0,0.0,1.0,2.0,1.0\n",
       "Path: .;\n",
       "\n",
       "Test: None"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = (ImageList.from_df(df=df,path='./',cols='path')\n",
    "        .split_from_df(\"is_valid\")\n",
    "        .label_from_df(cols='diagnosis',label_cls=FloatList) \n",
    "        .transform(tfms,size=sz,resize_method=ResizeMethod.SQUISH,padding_mode='zeros') \n",
    "        .databunch(bs=bs,num_workers=4) \n",
    "        .normalize(imagenet_stats)  \n",
    "       )\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-01T20:26:56.305887Z",
     "start_time": "2019-09-01T20:26:53.576097Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ImageDataBunch;\n",
       "\n",
       "Train: LabelList (2929 items)\n",
       "x: ImageList\n",
       "Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256)\n",
       "y: FloatList\n",
       "0.0,0.0,1.0,2.0,1.0\n",
       "Path: .;\n",
       "\n",
       "Valid: LabelList (733 items)\n",
       "x: ImageList\n",
       "Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256),Image (3, 256, 256)\n",
       "y: FloatList\n",
       "2.0,1.0,0.0,4.0,0.0\n",
       "Path: .;\n",
       "\n",
       "Test: None"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_2019 = (ImageList.from_df(df=df_2019,path='./',cols='path')\n",
    "        .split_from_df(\"is_valid\")\n",
    "        .label_from_df(cols='diagnosis',label_cls=FloatList) \n",
    "        .transform(tfms,size=sz,resize_method=ResizeMethod.SQUISH,padding_mode='zeros') \n",
    "        .databunch(bs=bs,num_workers=4) \n",
    "        .normalize(imagenet_stats)  \n",
    "       )\n",
    "data_2019"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training (Transfer learning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Kaggle competition used the Cohen's quadratically weighted kappa so I have that here to compare. This is a better metric when dealing with imbalanced datasets like this one, and for measuring inter-rater agreement for categorical classification (the raters being the human-labeled dataset and the neural network predictions). Here is an implementation based on the scikit-learn's implementation, but converted to a pytorch tensor, as that is what fastai uses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-01T20:26:56.332714Z",
     "start_time": "2019-09-01T20:26:56.307821Z"
    }
   },
   "outputs": [],
   "source": [
    "def qk(y_pred, y):\n",
    "    return torch.tensor(cohen_kappa_score(torch.round(y_pred), y, weights='quadratic'), device='cuda:0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EfficientNet "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-02T14:36:12.633626Z",
     "start_time": "2019-09-02T14:36:11.646362Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loaded pretrained weights for efficientnet-b5\n"
     ]
    }
   ],
   "source": [
    "model_name = 'efficientnet-b5'\n",
    "model = EfficientNet.from_pretrained(model_name, num_classes=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-02T14:36:14.532824Z",
     "start_time": "2019-09-02T14:36:14.358874Z"
    }
   },
   "outputs": [],
   "source": [
    "learn = Learner(data, \n",
    "                model, \n",
    "                metrics = [qk],\n",
    "                callback_fns=[partial(EarlyStoppingCallback, min_delta=0, patience=3)],\n",
    "                model_dir = '../output/models/')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-02T16:15:26.774295Z",
     "start_time": "2019-09-02T16:14:59.955370Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n",
      "Min numerical gradient: 2.29E-06\n",
      "Min loss divided by 10: 2.29E-05\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Explore lr from `start_lr` to `end_lr` over `num_it` iterations in `learn`. If `stop_div`, stops when loss diverges.\n",
    "learn.lr_find() \n",
    "learn.recorder.plot(suggestion=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-02T17:00:55.161260Z",
     "start_time": "2019-09-02T16:17:30.895146Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='4' class='' max='40', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      10.00% [4/40 34:40<5:12:04]\n",
       "    </div>\n",
       "    \n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: left;\">\n",
       "      <th>epoch</th>\n",
       "      <th>train_loss</th>\n",
       "      <th>valid_loss</th>\n",
       "      <th>qk</th>\n",
       "      <th>time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.365150</td>\n",
       "      <td>0.358262</td>\n",
       "      <td>0.870037</td>\n",
       "      <td>08:40</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.369809</td>\n",
       "      <td>0.362359</td>\n",
       "      <td>0.874296</td>\n",
       "      <td>08:38</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.373772</td>\n",
       "      <td>0.365699</td>\n",
       "      <td>0.876618</td>\n",
       "      <td>08:39</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.349093</td>\n",
       "      <td>0.401426</td>\n",
       "      <td>0.873442</td>\n",
       "      <td>08:41</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>\n",
       "\n",
       "    <div>\n",
       "        <style>\n",
       "            /* Turns off some styling */\n",
       "            progress {\n",
       "                /* gets rid of default border in Firefox and Opera. */\n",
       "                border: none;\n",
       "                /* Needs to be in here for Safari polyfill so background images work as expected. */\n",
       "                background-size: auto;\n",
       "            }\n",
       "            .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n",
       "                background: #F44336;\n",
       "            }\n",
       "        </style>\n",
       "      <progress value='153' class='' max='153', style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      100.00% [153/153 00:15<00:00]\n",
       "    </div>\n",
       "    "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Better model found at epoch 0 with valid_loss value: 0.3582620918750763.\n",
      "Epoch 4: early stopping\n",
      "Model save as: efficientnet-b5_0902_04-26-49_stage1\n"
     ]
    }
   ],
   "source": [
    "model_save_name = \"{}_{}_stage1\".format(model_name, current_time)\n",
    "min_grad_lr = learn.recorder.min_grad_lr\n",
    "learn.fit_one_cycle(40, min_grad_lr, callbacks=[SaveModelCallback(learn, every='improvement', name=model_save_name)])\n",
    "print(\"Model save as:\", model_save_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-02T17:00:55.524387Z",
     "start_time": "2019-09-02T17:00:55.163135Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEKCAYAAADjDHn2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnXd4HNX1sN+jbrlXjBuyjcG9CGFjqgEDNiaYFrADCS04tBA+QoKBUAL4FwcSICQEAgkmIfTugOm9ueNuXDFYuPemurrfHzuzmp2d2dmVtNLaOu/z6NHuzJ2Zszuz99x77ilijEFRFEVR4pHR0AIoiqIo6Y8qC0VRFCUQVRaKoihKIKosFEVRlEBUWSiKoiiBqLJQFEVRAlFloSiKogSiykJRFEUJRJWFoiiKEkhWQwtQV7Rr184UFBQ0tBiKoij7FXPmzNlijGkf1O6AURYFBQXMnj27ocVQFEXZrxCR7xJpp2YoRVEUJRBVFoqiKEogqiwURVGUQA6YNQtFUQ4cKioqKC4uprS0tKFFOWDIy8ujS5cuZGdn1+h4VRaKoqQdxcXFNG/enIKCAkSkocXZ7zHGsHXrVoqLi+nevXuNzqFmKEVR0o7S0lLatm2riqKOEBHatm1bq5maKgtFUdISVRR1S22/T1UWQGlFiJfnFKMlZhVFUbxRZQFMfusbfv3ifD5ZvrmhRVEUJQ3YunUrgwcPZvDgwXTs2JHOnTtH3peXlyd0jksvvZRly5alWNL6Qxe4gc17ygBY9MNORhzeoYGlURSloWnbti3z5s0D4M4776RZs2bceOONUW2MMRhjyMjwHnNPmTIl5XLWJzqzAGxL3p/eXd6gciiKkt6sXLmS/v37c+WVV1JYWMj69euZMGECRUVF9OvXj7vuuivS9thjj2XevHlUVlbSqlUrJk6cyKBBgxg+fDibNm1qwE9RM1I6sxCRUcBfgEzgn8aYyT7tzgNeBI40xswWkQJgKWDP4aYbY65MlZyLftiZqlMrilJLfv+/xSxZt6tOz9m3Uwvu+FG/Gh27ZMkSpkyZwqOPPgrA5MmTadOmDZWVlZx44omcd9559O3bN+qYnTt3csIJJzB58mRuuOEGnnjiCSZOnFjrz1GfpGxmISKZwMPAaKAvMF5E+nq0aw5cB8xw7VpljBls/aVMUQA0y1NrnKIoidGzZ0+OPPLIyPtnn32WwsJCCgsLWbp0KUuWLIk5pkmTJowePRqAI444gjVr1tSXuHVGKnvJocBKY8xqABF5DhgLuL/Ju4F7gRtpIIoOacOiH+p25KIoSt1Q0xlAqmjatGnk9YoVK/jLX/7CzJkzadWqFRdddJFnLENOTk7kdWZmJpWVlfUia12SyjWLzsBax/tia1sEERkCdDXGvOFxfHcR+VpEPhGR41IoJ5kZ6efPbYzhtAc+VROZoqQxu3btonnz5rRo0YL169fzzjvvNLRIKSOVMwuvHjgSyCAiGcADwCUe7dYD3YwxW0XkCOA1EelnjIka/ovIBGACQLdu3WosaBrqCr5avZVlG3dzxl8/Z83kMQ0tjqIoHhQWFtK3b1/69+9Pjx49OOaYYxpapJSRSmVRDHR1vO8CrHO8bw70Bz62Igs7AlNF5ExjzGygDMAYM0dEVgGHAVHVjYwxjwGPARQVFdU4om5feaimh6aMTbvKGloERVEIu87aHHrooRGXWghHRT/11FOex33++eeR1zt27Ii8HjduHOPGjat7QVNMKs1Qs4BeItJdRHKAccBUe6cxZqcxpp0xpsAYUwBMB860vKHaWwvkiEgPoBewOlWCPj3j+1Sdusb85qX5DS2CoihKhJTNLIwxlSJyLfAOYdfZJ4wxi0XkLmC2MWZqnMOPB+4SkUogBFxpjNmWKlnTkYqQph5RFCV9SKnPqDFmGjDNte12n7YjHK9fBl5OpWyKoihK4mgEt6IoihKIKos05+TemqtKUZSGR5WFi3RLU56XndnQIiiKoqiycFOVJrrCnlGUh6oaWBJFaXyMGDEiJsDuwQcf5Oqrr/Y9plmzZgCsW7eO8847z/e8s2fP9tznvM6+ffsi708//fQo19uGQpWFi33l6RGG37JJuKh6RRooi++27mVvWXp8L4pSH4wfP57nnnsuattzzz3H+PHjA4/t1KkTL730Uo2v7VYW06ZNo1WrVjU+X12hysLFrDXp4aFbZZnD0kFZnHDfx1z65KyGFkNR6o3zzjuPN954g7KycHDsmjVrWLduHYMHD+bkk0+msLCQAQMG8Prrr8ccu2bNGvr37w9ASUkJ48aNY+DAgVxwwQWUlJRE2l111VWR1OZ33HEHAA899BDr1q3jxBNP5MQTTwSgoKCALVu2AHD//ffTv39/+vfvz4MPPhi5Xp8+fbjiiivo168fp556atR16gpNt+oiXer+2uaw77bui9+wnpj5bXooUaUR8tZE2LCwbs/ZcQCM9qyYAISLHw0dOpS3336bsWPH8txzz3HBBRfQpEkTXn31VVq0aMGWLVs46qijOPPMM337jUceeYT8/HwWLFjAggULKCwsjOybNGkSbdq0IRQKcfLJJ7NgwQKuu+467r//fj766CPatWsXda45c+YwZcoUZsyYgTGGYcOGccIJJ9C6dWtWrFjBs88+y+OPP87555/Pyy+/zEUXXVQ335WFzixcZKVJoih76aR4e92MEFZt3sPabckrnnRb8FeU+sJpirJNUMYYbrnlFgYOHMjIkSP54Ycf2Lhxo+85Pv3000inPXDgQAYOHBjZ98ILL1BYWMiQIUNYvHixZ2pzJ59//jlnn302TZs2pVmzZpxzzjl89tlnAHTv3p3BgwcDqUuBrjMLF9MWrue4Xu0bWoyIGaquOPnPnwAknZRQdYXS4MSZAaSSs846ixtuuIG5c+dSUlJCYWEhTz75JJs3b2bOnDlkZ2dTUFDgmZLcides49tvv+VPf/oTs2bNonXr1lxyySWB54k3cMvNzY28zszMTIkZSmcWLp6duTa4UT3gfDAacnQfUm2hNFKaNWvGiBEjuOyyyyIL2zt37qRDhw5kZ2fz0Ucf8d1338U9x/HHH8/TTz8NwKJFi1iwYAEQTm3etGlTWrZsycaNG3nrrbcixzRv3pzdu3d7nuu1115j37597N27l1dffZXjjktp9YYoVFk0MA+8t5wrn5oTs73Ksa69dW95PUrkkkOVhdKIGT9+PPPnz49kib3wwguZPXs2RUVFPP300/Tu3Tvu8VdddRV79uxh4MCB3HvvvQwdOhSAQYMGMWTIEPr168dll10Wldp8woQJjB49OrLAbVNYWMgll1zC0KFDGTZsGD//+c8ZMmRIHX9if+RAsUkXFRWZIP9lP/rc9jYlFdVpyuuzfkTBxDc9rznhP7N5d0nYFvrFxJPo3KpJSq4TREl5iD63v12jYxWlpixdupQ+ffo0tBgHHF7fq4jMMcYUBR2rMwtg7OBOUQvbn63Y3IDShHEGB74ypzjh44wxPPj+clZuCk9jN+0u5aaXFtRCjgNjMKEoSu1QZUF4ETcnq/qr+Om/ZjagNDbVnXRZZeKxFnvKKnnw/RVc8I/pAEx6cynPz675OoyuWSiKAqosImRnNuxX4TYH7i2rNotV1iAHyW4r4jqjlnEjpuFjApVGyoFiIk8Xavt9qrKwaGhl4S529NXqrZHXj36yii17EiuzGrIUS6UV+V3buJGyUPqVnFUOfPLy8ti6dasqjDrCGMPWrVvJy8ur8Tk0zgIwmAYPxqusqiInju7+bMVmzh7SJYHzhH9c9mQkq5ZKcOikD2p1fGPmP1+tYWHxTu778aCGFmW/o0uXLhQXF7N5c8OvHx4o5OXl0aVLcB/ihyoLCxEY2KUlC4p3AuGReU062lCVYWdJBW2a5gS2dY6agsqollYkZg8KuUxWDa0EG4Lvt+5j8bqdjB5wcIPKcfvriwHqXFms3LSbLq3zD+j09dnZ2XTv3r2hxVAcqBnKgbOjnb66ZrmQLn1yFoV3v8eu0orAts74CXcn37FFHr07No+8r0wwoaB7feONBesSOu5A4vj7PuKqp+cekCaM0ooQI+//lF8993VDi6I0MlRZUJ3SwtnP7iwJ7uy9+HR5eNq8pzQ4pbdz8dmtDMpDVTTJqR45Bs08bEKudtv31exzHAis3rK3oUWoc+wsxJ+t2NLAkiiNDVUWFkK0WaiyKvVuQOt3VudvqXDNCMoqQuQ7lEWiyitI7gNxtO1HSfmBtzj/xcqwkth3AH42Jb1RZeHAaQoqTzC2YdKbS+h+85sx2xPpkp+d+X3ktXNmMX/tDvaWh9i2t1pBNM9LbHkpaG0j0RnKgcBNL9c8GLG2JGo2TJbXvm58ZkUlPVBlQXXHXpXEgrPN4599WyeZWe3rzVu7g7EPfwHA0vW7IvvtynlBPDV9TeS1ex0kfJ2ad2JV6VJzNkEWr9sV3ChFnPHXz1Ny3rcXb0jJeRUlCFUWFiIS1em3b57r39gDt3nnk2XxXf4Wr9vJf6c7ZhaW+egsS1G4STTtRqbD++mVubFpQq78b2zSQj/sz2R7VFUkYZrbU1bJpt3xUy4fqJSUh/hmQ3XW0HRXsovX7eTNBesbWgwlzVFlQfUCtzO1RbIup+6Kdm2axp8JjHkoeuRZGTCTSXRC0Ca/2mX3w282xexPZmHU9qxqYrloJmPCGvPQZw0Wo3F0z7YA/PKkQxvk+nbiRZtklGw8Flpu3XXNmIc+55pn5qbk3MqBgyoLB84OP1lzjdtlNT8nuRAWr5QeznWKUAIdTmlFiIc+XBl5n4j7blyZLOWQmx1+THbsC06VvnjdTlZs3N2g5WC/XBWOfq9JmpRUEDQQSJTfvDS/Ts6jKDUhpcpCREaJyDIRWSkiE+O0O09EjIgUObbdbB23TEROS6WcXtR2IfjmV5KrGey1IPq/a4+leW5YYdxmBXjFw71GMe/7HUnJ4MYeEW/ZE1YSk95cGnjMmIc+55QHPq3VdeMx89ttvL/Ev4yl08MsVYvMybK7tBJjDF+tql36ikbkyKakISmL4BaRTOBh4BSgGJglIlONMUtc7ZoD1wEzHNv6AuOAfkAn4H0ROcwYkxJ/QePhu5Ss66x7TeGHHcmVNfRSTs3ysvj8ppMYdNe7vsfd8MI8Xvv6B2bdOpJvXXEFe2vpXukeEdc09qSuWLZhN+f/4yvAv7bGi7Or12nSxfPrqD98wKXHFDDlizU8NH4IZw7qlPQ55ny3jWUbq9dBTul7UF2KeODww1xYPw8ycyErFzJzXP+t7V77svIg48CNiq8tqUz3MRRYaYxZDSAizwFjAXdV8ruBe4EbHdvGAs8ZY8qAb0VkpXW+r1IhqDHRC8OQfEeTqKutH17KKTszg6Clk1fm/gBA0aT363zk6R6Z15U5BcJmvmMmf8gdP+pHZgaUVIQCc1+d9mDwjGWbIyq+Np5fNWVvmXcw5pQv1gCweXdiCSHdnPtISh79tGXz7jJ27Cun10HNgxuX7YFFL8HsJ2B9LU11kpm4csnMCSsYT8WT66+wsvISVGK5kJE+KwWpVBadAWchhWJgmLOBiAwBuhpj3hCRG13HTncd29l9ARGZAEwA6NatW40FrTImplNOpKNxtimvZcfk1RFnZ0YLZYzxLP4e3pf4tSb8ZzZ3nNkvsPqeO1AwaKHWy8RSVWXI8NB42/eVs2l3GXdMXRQxcyWSKDGIr9dWm97eXrSBSWcPqPU5kyFoRmkXpaotiZrYyiuruPrpOVw1oidHHNImqWt8s2EXz874njt+1M/zHqaS0x78lG17y+NXZ9ywEGZPgQUvQPlu6NAPTv8THHZaOLd+ZTmEyhz/yyBUDpWlHtvs165tXu0rS6F0p6O9x3USirRKgIysOMolp3pfh74w6v/q5po+pFJZeD1dkW9QRDKAB4BLkj02ssGYx4DHIFxWtUZSEk7z4a77EPRjNMbQ69bqIut+I8pEufTJWXzymxFR27IyMqLMW6EqQ1Zm7X+07y7ZyLtLNgaWSU12ZuG1nlxRVUVunKl9ImvQz878ngGdWwY3BMYM6Mh8S2Fs3VvOlyu3cPSh7WLaff39dr7ZsJvxQ2s+yPDi8U9Xx93/1qIN/OGcgbW+TryZ75crt4DA0T3bMfu7bby/dBPvL93EgxcM5qwhMWOuCO7ByK9fmM/idbu48KhDOCyREX4dss2v7nz5Plj8KsyZAsWzwp1lv7Oh6DLocmQ4I2hDYwyEKupIUSWgxMr3QGnt1icTIZXKohjo6njfBXCGnzYH+gMfWw9oR2CqiJyZwLF1SpUxMc9YkBnKNivY3PjifGbcMjLha/bu2DzKFx9g8lvfRL3PzpQol9mKkCGrFibVk3p38HSn9cP+Ds4p7Mwrc3/ghMPax23vZUqrCBlyPZ4y+9y+nYKDZJwFOrlmS1t9zn/2378EiFIW63eW8MB7y7nnrAFRlROT4Z2AoLn8OsoUG2/m+5N/Rpb/GNmnem3j+ufnMXZwJ9/ZaUXIkJNVvc92mGgIc14Mm74JK4j5z4ZH9e0OY2H/icxqeRqXnVLY0NJFI2KN+nMguXCttCaVBrFZQC8R6S4iOYQXrKfaO40xO40x7YwxBcaYAsJmpzONMbOtduNEJFdEugO9gJTVOjXGxM4sAkwuzuhqgI27yjj2jx8mfE2vCnbuH6WIRKVJr6m//nUnHcrCO08lLzu5220H1Q3q0gqADi3iP/leEeN+azmn/+WzpGRJlEzX9xo0cSmY+GZExltfXcQLs4s54p73atxB7gpIIOlMDgnhXE8FE9/kmmfmen5/fiTqFvz+0mjPsXjHuU2ptlKpi7Ww177+gXVJOn3kUAELXoQpp8Pfh8Gsf8Ghp8Alb7L+ok/40eyB3PWBBhPWFylTFsaYSuBa4B1gKfCCMWaxiNxlzR7iHbsYeIHwYvjbwDWp8oQCqKqK7by37ok/4n1xTmx0dPH26B9DPFOW17rVngBTVjILzHeN7Rd5fcagTjTPy6a8Mvr4W19dyCMfr/KV8xZrRD/z220JXd9rNvb8LO/633XtWXXzKwsY+7fPY8xaibiqFm8Px4TYs67dpZUs/CH5ALgvVwUHPNrK4skvvmXu99uZOi88YX5zwXoWJXHNmiqzePfQrdjdA6KaUhGq4vrn5/HjRxNcpN+6ipuznuar3GvhlZ/DrnUw8vdww1I4719QcCzXPKMp2uublC61G2OmGWMOM8b0NMZMsrbdboyZ6tF2hDWrsN9Pso473Bjzlrt9XWKboZxmln98upoVG70XIxPpFCB+biKvmUVQDQ33uki8NBJON1o7r5R7lPn0jO/549vfMMpnlG8rL3udJGjk67U/GaVQG3PHszPXMr94p6cbdBBeR1RVGfrd/jbPz/reY683z82MVow92zeNaZOfHbbJ3fm/JZzz9y+jFo6Xrt+VcGqQmroF97n9bV8F6jcLrG1wo73uFjf9S6gCFr8G/z4T/lrI5ZlvMaOqD/z0VfjlXDj2emhW/fucm2AM0b+/XMNvPYIZP1i6kb+8vyK5D9LISR+/rAakyjJDTbnkSJbfMzqy/ZQHPmVJLZLRxfOQ8rMbx+PUBz7lg6UbKZj4Jut2lLBmq3+9hhZ51elGvBSTk5Wb9nhut5WFfa6gTsPLdNe5dXyPKycXPj4juFEAbhETWRPx6jtLKkLsLQ9x51S3p7c32/aWM3V+9LLanzwq5LnNUM5ijBNfWci/Pv825piyythJdW0CDst8lIKvsqjlmoX9/XrqqO3fwQd3wf194cWLYdtqOOl3DC/7K1dXXE9V9xNjpuHJzHjumLqYF2YXUzDxTZ6ZUa34L//3bB54f3lNPk6jRZUF4Q4mM0PIyJCYhc3TH4oddbdrltiqVbx6Cl6eiPaawg2nHObpqVRSEeLyf4cnX0dP/pB1O/xHahcOq164dceQeLHbIzXIL47vCcAFR4Z9DYJSjnjNLDq3SrxA/Mw1sTOrZL3M3KPm3/9vCXO/3x50VMwW+6MkqtO/slKMOMnysDU2zXUpC9cFvBT32m2xqVNqMwvzVRah6ud1w87qZ6u2wY329SKDjVAlfDMN/nse/GUQfP4AdD4CfvIC/Go+HP8bNtM6+hgH2xNIO+PFLa8u5Lute7n/PVUSNUGVBd5xFk6c3jg7Syo4NcF0FvFMMO5OAuC0fh3D+1zCtMr3TkoYT+Z8hwuSfa2OLfw77r1lsYrNzrxr/w/qNLzs4e51kiDco9tRf0kudYjX6PUcy/PJD69+N9nRtFciPi8357zszCil6o5fWLw+dt1i5P2x30FtOnCvmUp4e/VnLq2oblPbQmBvLwovQh/ENvh4Mjw4AJ4bDxsXwQm/hesXwk+eC8dHuNysvX5DyTgCuLnu2a956IP6Mz8NnfQ+D6RQOZVVhvjdawvZsqdmwZ7JoMqC8Cgynlno2ZnfRx7QZDye4kV1e11unhUf4M5426mltymnbZwZjlMZ2QPcx39W5NMa1m6PHb1WOVKUZ0jwj9RrFJjsCLikIrojW7st2IPGOZuwOxe3wr3ttUV852O285JxkxVpnWhFOq8Ax7bNcmK2vTL3B377UnVRplLX5130Q9jEsnVPWVSeKzd+HXgiC/p+JX+dz6vz+Xxr0YYa57TatHMfuWs+4rHsP/NF7nVhZdGhD1zwNFy/CE68BVr6B2MeOel9CiZGFxd7zsdpYur8dfz7yzU1kjNVbNpdxl9SqJzeXrSB/07/PqG8bbVFlQW262z8NvaPerfHD+1wV8DSfy8PB6r7xQeUVYY8bel2plZ3R/fbUYd7nideR+y0gNjnG9ClOrCtU8voWYaXp4o9U8jMCLvwBq1ZeJmpkh2VvrdkY9xF3vFDu8bcK2fzO6aGEy4+8/OoZAE8Nf07TrjvY89z/sMjkC7ZRJCXH9s96v0Hvz6BDs29Z3IvO+qM/OBjSjxy0vsM/4P/wMRvZrFhV3ANkb99tNJzu1NZOAcGz8z4np89kaTn+p5N8NmfKfvzQM5afB1DMlbwWOgMuO5r+Okr0OcMyKxZmFexh1kOwrMG+/77sSXAy3F/pT4yLKuyoHqBOx797njH1wsq32WH7mh1xH4L3APufJdVm8Oj3BtOOSxmv3tm0bN9M8/zxFMWUTMLj8+2bmdsp3LNM3P5clXY73/Jul2RmUVGhpCVIYFrFt4zi+Qe4htfnM8jn6zy3f/tlr1UmWhPMC+F1CzBMrQAG60Otp3HTCBR8lzBdvY98/KIcuK+M0MLwik57I/nN6L3u/e3vRacnfjdxd5Ze53Pq/u+JVQHpaoKVn8ML1wM9/eBD+5irWnPNeXXcXTZ37i3chy06R54Gi8unTKTC/9pZQByPc+vff1Dwudxp2NJl8zEtaU22YwTRZUF3nEWXjw93duN0m1uysmM/7U62193cq+Y/Zmu472iiTMzJG5H7AzmS7SQ05sL1nOt5b/+4TcbI4ucmSLsKw/x+Gff+ta0CFWZKG8TG79OLV6E9HIfl2Wodi8e7XD39dJh7s7bxsu2O35oV9btKGHLnvKEa5278bvlH/x6RNzjgsx0fvfY77hE6p74xfPY9dsf/WRVQkkbI+zdCl88BH8rgv+MhW8/gWFXwrWz+UnF73iz6igqapks4qNlm/lipZXi3dUxXv/8vBqft7Y53RqaXfWYCVqVBeEKeYl4vbT2qH7XJDuTCcf3iNqWl1O7r9XduWd79ESXH9vdc1TUpXUT3vjlsVHbnGat1685htw4HbVtHvvTu8v5p+XG6Tz+67U72LS7NKbTfWbm9/znq+9izlcZMvz6hfkxLqHxRkKvz1vn60lmp/d2puv2CqDz+4xF97wf4120dlsJR08Om3y8zIxulq7fFbPW8NrX/tlozhrcyTdVivs8Za57+sJsb/t8aUVVzLEAs9YEeX75c8Pz85ixemtM2hlPjIHvvoSXr4D7e8N7t0GzDnD2Y3DDN3DaJGgXPRDq3i7+LMsm3lrflj3lnDEw+RTvNgVt86Pel1XUj7KwI/U/XR6/3LIX89buoGDim56ecnadm/pIxq/KAu90H1409ah+t/TuUTFeRrateuzgTlRVmcCprnvg716z8Or4qqpMZFR077kDOa5XO5beNYrPbzqJ/q6ke87F+0FdW3H2kM4080rY5INTnlDIMHTSBxTd835Umy0+qbeXb9zNy3OLufuN6HiFIBPrZys2xyxsAny6ovrHtnbbPkrKQ5EaF0683FZt7LWhfCvmIRlXys27yxj9l8+iapnf/MoCvlod6zpr8+C4Ifz7sqGe+9wL6GUuBbDEEVNw+xl9o/b1vi26fCsEZwGwWbZhNzNWb2XnvoqIy/buskrWe5gnbYwxULIDpj8Kfz8KpoyG5e/AEZfAVV/BZW/DoAsgO4+te8r4w7ToRVcv92wv4q1zGWPo4hG7k2jw5Gn9O0a993Mj9mLOd9spmPgmP/1X8vFAF1r5upJe+6E639hbC6tTmxgTHoRVb0j6tEmTykSC+w12nEUQBvjRoE78zxV8tbfc+wdaWWW46eUFvDinmJ8edQh3n9Xfs12nVk2iUoW4ZxZeyqKyykQWoHsf3JzzjxwW08aP3KyMhDsViF7/KPbwmgJ/T6lVm70D/qqMIScrIzKKPOygZizfWN322me90znkZWUC4U7nuHs/4pKjCzzbxdP9F1k/9iML2vBJkiM9u1Ttx8uqj3t2pvfoPxHcySTdnVeeI3Pk0Ye2rfF13DjNTD3aN2X15r2cW9jFJwLeMFhW8eJtYzk/byZUloTjIs78G/Q/B3LCM4bte8tpmptFTlYGd/5vSczvJJEBGcRfrK0y1f1ik+zMiPfcTS9HOyR8+M1Gz1mW22U9GW+9cx8Ju2AnWsf+mw11ky7F/v1/uWorv7TM1qs274lylKgPdGaBd9ZZL0orQjE/APBPtPbmgvWRHFJPTf+OLXvKOPWBT2LauX9EbsWV5WGGClWZyAjMy0wVj2QzqjpjAb7wCD6D6B+dc6HYy/XUGIMxcOUJPSPbLjsmeuHTzxSRnRX93Tzp4yqZyP101wvxomlO8lli3WbAZCgpD/kqXq/YnGTIycxgcNdWMdudz6/zdVNKuDDzfd7MuYXXcm/n9MwZVA0aB7/4FK74kF1q8UcWAAAgAElEQVR9x7Foc/WgY8jd73HY78KZeSo87l+iz2k8b7iKUFXE8eLOM/t6tqmqMlz25Gwe+djfUcImmZlFssQLyk0Gu39wzl7dfU5N0twkLUfKr7Af4FXPwuaqEdUdmpdNHqI733jlLovueT9q9GzjntTEM6HYVFaZyGzEr9MbP7RrzHoKQG4t8pz7dVizHNHXv3Is2i8ojl1PsPsC57nOKUys8FH/TonVtchO4Dvcsa92i4Pv+qQj96v98K+LveNcenesbl9aGYpKvuhMl5KZITxxSRHnF/l/V7YLr9czYTCe5ke78y0PVWEM9JM1/F/WP5mRew2Tsp8A4JaKyxlW9jDLiu6Cg8NpTC5+YiZn/PVzXvZIqunVeWVkhG33frNTm3jxPBWWjOHP6H2P42Vn/rtLgdS2wmU8auos4cY5eLQHm+4BZX3UZ1czFLBjXznNcr070BtOOcx3hHLveeEiNkO6tY5su+6kWO8mP+xALreiSqTAUaiqinusQBy/H41fkZ2a1moAYtKc/+erNQzv0TYqsVuLJt4R55WhKrIyMyKzkKxMCSzABOHUJYO7tmLu9zu4cFg33loUv2YEQNME1mRmf5f8YrAz/cgLs9dyar+OMW38TJp+Stq5plRaEWJPWbUSc3o3ZWVkcFLvg9ixr4IXZnubIEJVhhZ5WSy48zTPNR+ve19lDE0o5chtb3Lal+9wbu4CSkwO/wsN5+nQycw3PbGdfJ3P2tfWPf/1i/M594hgZZ8hwoX/nEGT7EyW3j3Kt108ZbF1b3lEufl9z8mUrk2VN9Tc77dHpUypDc7+wR5suvsMVRb1xHdb90UWPZ0EdWR9OrYAoFluFsvvGc2Xq7ZEBb4lysMXFka5gnqN3t+/4QRmrdnGu4s38NGyzVFrDl5mqni4OwyRxB829+/49tdj/fqb+Lit7qsI0cIR3JeIGSjcLoMfF3Xlx0VdE0rsOKpfx4TP7aZfpxa+2YJDVYbX51WbIf1s637LX35K2pkYr7SiipnfVisxp7eOPVmKp+zD1RRj9192THfOGtKJh10BeYfJWiaUfcKpuR/TYvM+9rXsxR0VF/Nq6Fh2Eeu9lMjaHsA7HrEc9jPmjtKP+QxxHsYfP/oVt5zeG/C3BiTjsJDozCLRHGU//dcMhnVvw5/e9ZZhUA36B6+ft/vZK/VJ4VKXqBmqFjif1ZysDEYc3iGp4+1RTZ+DW1DYLdaW7OTQDs0YP7QbUy4Ne9VMW1g9uk62Y3TPRJ6+PPHFcWeZVz/bsjuzqo1tw7W9wxIxtwG84ljIS8Q2e8/Z/WuU1RegTVP/wLyet0yLyizrNwL2u3Y8l2UnzlTy+xwdq/19OeN4YkrfVnl79t06pg8Du7QiJyuTXMo5K+NzXsy5k3dzb+LM0Lt8UDWE37W+j3k/eot/h07zVBRe10uG730ir2OvEf8e/9+0sGuvn+J6ZW7iQXpuZRFeT4u9/hJXpts1W/ZGgjltTrjvIz5bscVXUQDM9zDLBuG+n8s27I559upqfSSuHCm/wgFMVZwRkFdktpvrR1abrJxnindeLxKxzzt5whHzcPfYfvRKor7yGwuq3ff8RtYdW+Rx3UmHxmy3R8l2oFmiSs5ZfS6R7CG1MbPF1AxxfUSnicO+T04l8OSlRyYklzuy2ys4E2CfQx6vmYV7gTZUVeUZhJkhwJYVnLv570zPvZYHc/5OW3ZxT8WF/Cj7n/y/imv47/rOmJiY8mhqm4E2ERJ9/hOc5MTF7Q3V/eZp3Pjigph27gHWiD99zLD/+yBqm5d1wguv+Jh4uD0Xn5q+hj+9uyxqW7J9Rk1QZeHBJ78ZwZvX1dyjBRLrsC4cdkjktfNeJ3vjE1njcOIclQzv2S5uudV48Rh+I+uszAxuODU2n5XtvWX/QN0/wEcuDK6l3K65/8h//NBuXHlCz0j9jRtPPSypeBKAg1s1iXJSKKkIUTDxTU/7v/35Tx9wcGRbvNmlU6k8eMGQyOvDDmrGDaccxqSzY12rVzuKWNmPhfPZcnc8oaroEXc2lYzJmI78+0fwtyKO2/YyX1T1Y3z5rZxU/mf+GRrDNqoHC0HP3ukPfeZZxMg5Gq9tCo1E8xzVdPboxMsbyu2SOmvNNs56+Iu450km3Uay/fqDriJNs9ds570l0WY+Ly+3ukbXLDw4pG1ikabxbvony5Lz34+eWSR1aMLmHJuxgztFkueVV1b5psYAOLpn2Lf/kqMLYtxU/YKn/NKL2J2rbWZw29ZHOzpdJ841kINbNuGCoq4874psnv27kTF1Rq49qRfXntTLs6MHOP6w9jERtRcO7ebr9eZm+uptLPphZ6SDffSiI+K2d3bybRzuxZnW/cvOgDzKyKOcJpTTRMrYunINhRJ+nbOyEnIq6bRhCxdlLqUJZax97XPaHpQDlaVQsY/xxesYW7EHnvobz+f8QE9ZRzvZBTu6wcm3c9nXvfhkXfT9tmdLHVvkRbLegv9a1itzf4hye4boZ9Zv8T1REq0W2NLHkcKLoQVtPOulJLLAHa8c7Pa95bRumpNUIr94azKJ4BUbEi+Ysq5QZVEDLj+2Oy/PLaZHnCRxQfZZ9xqFM3I32ZlForZwm4Fdqq/du2NzMjKEl64cznkeP4r7zgu7Sd40qneMsvCNB/BRFvYoriISH5LYyPAQV4qGooLWMcoi2e+sZZNs/n3pkXS/eVrU9qMPbcd/Z0Qri0xCNKGMJpSTK1ZHbnXqs95fR7/SvRzUagejyjbD9BKosP/2hf9bHXn7kj38N3sdTaScg5/5Pz7I2UoTKaPZjgq4p5LzK0s4P16tKKsYcQFwj91PrgS+zYHsJpCdzyGlwi6TDaXtqTIZfGH6c9Bxl3DUyB9DRgbb538OeNvNK0JV/PHt8HrAq1cfzZBurbn7jSUxqVq8vI1WO4Ivb3k1uYy9bhLteLu0bsKUS4/k0imz4ra74rju9Dm4RURZZGYIp/Q5iLcXb6i16+zu0kpaN81JqsZGqJamPDsJqZM3Fqznbz+p1WkDUWWRAF3bNInUVejSugm3ndGX287wDgiyCZohN8uLHhU5I3mTnVm4C+gEMWbgwVzzTPSxRVa2UzctrcJLXmY1vzgFP7PYOY98yfJ7RlfPLBKcEbnrcLir0mVTiZRsD1dgK99r/e0Jd9ble5nQdBYH5YXYsWM7eVZnf3iLLOSVF3kk+9vIKP6ITk3g4bv587493Jm7mzxLQWRLHBuzsx/9n3OHWB14uBMnK4+srDxypYJ9JpeM1t1YvL45JVW5tGzanFGDu7N8W4hXFm6lhFxKyKHU5FBKDiXk8s/LjyO3SVPIzmfVjirO/9fXlJDLk1ccz9Ce1Xmn7nh6Dis27uG9K06gy7Z9ZOwoYViP6shvr5Q1NlsdafPtVN63ndGX343pw7tLNvKLp8IpTrzu+ytJZH71Y3dpBYV3v8f1I4PX+yC88HtU9+Co9syMjKhFYmMMvx/br06UxduL1zPh+J5JDVaSTds/fmjXwCwBdRXTEQ9VFgnwl3FDItXWEs3gOnF070gGVy/8cikBHNXDu+Oua+KtVbjxmi3c9voiz7Zu741JZ/fn1lcXUVFZCWW7+WbFcgpkPa13fwPfranu3Mv38tmIzTzz2VLypZR8ysinlE7vvwSV+yLtbtqylRtz90T250gI/u4v+y0Ae4FsKDeZlJKD2dMEilswqAlsKs2glFyymrWF7CY0yc7n1bmbrY46hxKTSylWx229LrE68RP6dmXDPuGHvfD45cdDVp6lHHJjRgwVFSF+bOVzWjN+DN9/uII/vbucYS3bMOrU4Xy7eAOPzptDk+xM8nMyozrvnB7HRM5nzG62EjYjnv/4TL79w+kR+31lyETuVdc2+XRtEz0ri5fDysk+RwobEYmqv/Ly3GL+fH50ffH1O/wLNWVlSNRsoa2Px9mKTXuoCBnueye8eHt0z7Z86ZMxAMLPmXNgkp+T6ZkxICtDom5Flan2KPOrGgjhheWgNS9b2Uyd559I0k2yTgKJpJNJJAFmbVFlkQCFjqC7RGMahgWMeNyueDZH9WjjWzSnLplxy8kx5qup1x7DmX/7ggnHdefJz5aTTyns+D4yWj86YxFNKSWfUvKljILNMCRzJ/lSGt4upTSljBYv/gOqSnkrZz35lNLuvQrOzt1HvpTBH2AsMDYXeC9Wrq7ATdkQMsJe8miS35zMDc3D+YdymkF+O6o6HMTna0rYSx4l5LLX5PGLUwbQokWr6nY5TcN/2U0jrw/9/SdUWo98TiiD5b8aTccqw4/v/YjR/TtylGO2eMtM73UON4tWZlHYrTU7ssuhRfxsqHYHdfPocJzAIGtR0h6V2vtLKkLhKnsOa0P0Yq47v5Ehx0qDEqoyCcdCxMPdobkTHLp5LU5nObxn26h8Sp08qgqCV3Bq/N+aSPTgLS/bW1l4fR92DRqn99sNjlTn01dvZdxj02MSQPbu2DzKCjCgSysqQ1VMTKJYVm3qpzckqiySJNGZRa5j1H5uYRfeXbyB3QkE9qzc5F36s07ZuoqDPrwn2mRTvpeB5XtZ3WIPMnsvt+RZP7oHqw97xj0gLAWyodRks5c8KjPz2V6ZQ1blQZDbjLWmPXvJ49ieh/Dq4p3sI5frRw/h1mnfstfkcflJ/RjQvVN0557TjAv/s5AvvtsLCGt+HxsYOX/Ren67Mrrm9dXDT4OAUWDr5k0j9nZ7RJiRIXwx8aRkvr0odpdWJtxBZ2RER6zb3mD2oNvpHZYfJyeV28RZWVXFrj0VhKoMZZVVdaIsureLnpHku77bqR450uJxwymHRYLl/Ew/7mDUnIA1LZGwEs3MEEJVhjyftbvsTIlZqLcVc7lDKTpNaR99swkIpydxcmLvDlHKIlRV5bmGEI+6rGr32E+PYMJTc2rlLp4oqiySJFHTpNODxxhDs7wsdpdV8p/LhvKzJ2Yyso93DqlEXPBuGtU7shA5dnANcvtXlsGGBdWj8GYdIp11htVx3/vhWvaRx53nDo20O3/KAvaSxz7y2GvCo/p95BIi/Fk//c2J9HYsRu+ZW0yVgXaFnfk/ayH5+mPG8PT/wqP2s7sNhZ6xdR4ycvIBfweBEw6LdU9NJL3H69ccE6lbEVSgKhkqq6qSjqKH6oGH3XlEm1SqP487mWGPdk356VGH8NT08EJ8RaWJSRnvxxXHdefxz74NbDe4a+uo98N7RM+Ur/PJCuzFQS3y6NepReS938javdbldq12ZybevreCDs3zIsoi18erLzMjg6Hdo027IuHqj7abr9sDy/YWdLsmDy1owyNUp/8pr6xK2MHk3MIuvDy3uMYzi09/cyLH3/dR1La2zXKZd/spdTJACEKVRZIsi1PFzYnzQQ8Zw1OXD+WVuT9wXK92TD5nAKcPjHYT7dWhGSs27eHsIZ0Dzz3E4Uk14nDvojpxOagv/HJO3CZ/fy/cod9ZWD0SnmniJ95zuwR6JQd0KkO/xzvITuwXIR6E0/yx6PenxW077/ZTeH/pJm58cX7cdhDOrJtXg+SMdvr2+WvDOZb8ZhadXfUbRIQ7ftQ3oiySyW9065i+3Dqmr687sY2773GvfSTCoxcVUlpRxan9DmLG6mq3VT953R2e24V9eI+29OrQnDetug4dmoddpbMzhHL8Z/1ZGUKnVk148ILBUVX1sh15ytyp4m3cHbt7VnDlf+dy0VHdPI91c0rfg3h5bjGrNu3xTDb5wqy1HNm9jW+RqG5tY++BMYZW+TUvB5wMKZ27iMgoEVkmIitFZKLH/itFZKGIzBORz0Wkr7W9QERKrO3zROTRVMqZaipCVRzaoTm/HdUbEWHc0G6RwDEb+wEpKmjtdYoonB1JojUC6oNEKqE5XVX9ZK+PzxQ0bW+Vn8OAzonl8VlQvNPThz8IO3Le/rg5PsrCK1OxcyZTk5Hq7N+N5Kub/c1vdRHwlpedyVlDOpOfkxWlCIu3l3jOoN3upyMObx8VqBgyhjvP7Bd5b3sA2UrGb3Rtb3dHQmdnVpcmvvaZuTHHQXjtxrkg7xVw+F9HueXJ5wzwPA8QWVe66mnva/325QWc9kAS5WyJn3SxrkmZshCRTOBhYDTQFxhvKwMHzxhjBhhjBgP3Avc79q0yxgy2/q5MlZypxF7AdOZx8sMehfdLIAW3syOpix+1Fx/dOIL/uBb3bj29T9T79s2jg+CSxW/mbP+4f+GRXt3m/RtO4A9xfph+/L+Rh/HK1Ucn1NbLBbh7u6Z88psRMdtb1MB10T6mh6VknbU6/EwqXtSkJkO7Zrkc3NJ7obmucCqI4T3bRpmi3BHIENvxlVdWMcYRqHlyn4Oinhn7ObGv42fBteN53nGllM/JCs8sPlm+OSpS3kllqIoujllVRUDn3C3ODMzPVXzG6q0RJWTPuj5ZvplpC9cHmqVT9fv3IpUzi6HASmPMamNMOfAcYUeYCMYYp0tQU+qnlGyNcBfnSYT+jh9HEKP6d2TN5DEJTfed9uyFxTvitKw53ds15XhX3egrXJ13qyQiaD0JUBaHd/TPWXVoh2a0zk/++r8a2SvKuy0eXmaNu8b245C2TbnHUfWwS+smnNI3NlV5EC2bhEeso6xSn87ONRnl88/PVke979WhWdKyOPFz3V4zeQxjXObT8UP9TTDO7y8zQ3jzuuMi73eUxJo03bEKZa7sAice3iHK5GJ3lPbzUnhItXnWmZvNjpC3a31Uyxeu1HhxnFKnr81bFzETQnAqk+w4M1av52np+l1c8Nh0JrlK0F78xEyufnpu4EAg0dlvXZBKZdEZcDoIF1vbohCRa0RkFeGZxXWOXd1F5GsR+UREjnMfV9/8ykr65+5A41GaomLwzjQHHyzdlJJrJMLmPWHPorMGd4qMjpMhyAwVNMVO9ajKy6xxdM92AFx01CH0PTg8GKgIVdUoJXr75rnMvOVkfn1KOI+W0wyVTKnWp2dE15/OTSJ+xoteHfyVtLv+tV86eojv+ur1bbnvd1lliLzsTF68cjhP/zycGdnrnthK1lkvZKAjFbjdSbvT2mRnSaSSZaIEeTI55XMPZpz77CyxdoDj1997D/qG/yE6WeE/XQGqNV2/qwmpVBZez0PMN22MedgY0xO4CfidtXk90M0YMwS4AXhGRGKG6SIyQURmi8jszZuTy8WULC2bZPP5TSf6VjvzIp77Y21wnjfZkqp1if2g33ZGXz68cUTSx/t1rz8dHk6weGyvdgmdx+606xrnQPeK47rzytVHR/3gj+0VTsJYETI1vg8dWuRFouiTTQjp9vCxqa2nl71w7oU7w7G7zG3UvjifZ2cCMwv78x1Z0IZjDvV/FuzvzWmyca5J+a1p2FkZkqEyZCIL615kijCoS0vGDDg4YqZ945fH8t7/Oz7q/v7S8iaz5Zy31ltZbLd+Y0daa5kHtaiOwXKbiVNNKnuaYsIxVjZdgHjO2c8BZwEYY8qMMVut13OAVUBMDgBjzGPGmCJjTFH79jXwCkqSLq3zk+oUfjPqcE7texDzbj+lTuVwjqjrw786iEQWpL2S7DlzVDkZ3LUVayaPCbSpjzi8PWcP6czjSSjwmtC5VRNuHdM3xnxVWhGitKKK0opQnShtP5v28xOO8tzulwY/mWciXv0OL9yfM14yv3jpXOwqj06cFp6sDEk4ONWOnfm3IwGk89p2J10XjhM92jfl49+MYP7tp3p67WVmCK9feywPX1jIE5ccyW9OO5x+nVrQ66Dm7C2rdsO14zcSnZEOsn4rzo+QjJWjLkhlTzML6CUi3UUkBxhHJBVaGBFxJvEfA6ywtre3FsgRkR5ALyDaMLsf0CIvm8d+VpRS17azEnC1TTWJ/Aa91hdqO4XOzcrkgQsGR8rT1jX2DM7PQ802Ae4rjy6FWlOcnU+GVK8dDOvhnQ3A73PnJOHGay/I3nZG37j14232VUR7FB3Sxt/8mBNn1uGF0wzVs33i6y5eUdtOhWnnIrO9mi4o6hrTPhE+++2JHNWjLfk5WbTMz47xroLo2UuX1vlcc+KhkcGds72dHypRZybb/NWQzo8pUxbGmErgWuAdYCnwgjFmsYjcJSJnWs2uFZHFIjKPsLnpYmv78cACEZkPvARcaYxJ3jexEVCjOIta0LFF7GgvkbWDmgStNTRtm+Uy7brj+OO53rXMf31q9ci+tmm5IVp5/v3CQqZcMpTPfnuib3s/V9FkFsdt80f3dvkRV9RBcWojdHLN9uLd1iZxkhZ64TRDOV1kE+VwR+yCcy3ldSvavKBdU165+mh+Pzb5c0NisSbxMjw475ftshtUJ8PGzvjcPNc/sWeqSekVjTHTjDGHGWN6GmMmWdtuN8ZMtV7/yhjTz3KPPdEYs9ja/rK1fZAxptAY879416kL6iNrY13y6EWFdGyRR0GCtTfqineuP55PfxPdgSWSAqWmNbEbmr6dWvjW+3AG+TmrHtYGewG5eV42TXIy43ZQfsriplG9k77u91v3Rcw0F8bxcLr46ALm3hZtVh13ZHik7h5INPNQFk5FNs0Krtu0u5SBd77Dwh/CqdNfunI4w3sGZ5N1c9mxBbx81XBOPLx9VCXCCcdVe/EVdmsdt36LVwEqgNP6Bc+6IH4G6ERTBcWjW9t8plx6ZMw9qA/2v+FeCmiem8WPj6jZ1LShGNX/YKbfcnK9hPk7aZmfTbe2+VEmi0RSbTTkQnyqcI6E6yr5Y/H28KKr3XHGw88Gn4xZzr6Pp/TrGPk8QRNF5zqHMXCp5VburmLoZWb8x0+r15eutoLTPlu+hV2llfzjk3AajaBnul2z6OsUHdLakls44pA2TLl0aNRMNpl4IL8U7jecElv50Qt3fisnic4Gvly1JWabM7PDiYd3SLoCZF2wfw2nlbRhp+WlcekxBQm1d88s7Myr+zPOug51rQv9aoU48fO2S6a+yWM/PYJQlSErM4OLjjqEV+b+ENfzyE2VCeds+sUJPbhw6CGR3EXjjuzq2TkO79mWkX068L613rN84+6Iq+9ea+0haGAx7VfHRZ4/qFYufsozmXvjtQ7hvEYQ8argHdMz+nud8oV3jq6fPD4jZluiM5tUcuAN92pA2kYCpjF2eospX6xJqL27A/iFqyzn/ojTLi6+jsA1IxG360RmdEGISGQUXtitNWsmj/FNIe6FwSAi3Dy6T1Tuosk+6zwQ/Sxs3FUaSVdiZ6MN6pg7NM+LpEoBp7eT3xGJ3xu/IMNElUU8j6uMDImY7AB+/78lCZ2zZZNsTuuXfNBnXaPKwiKNUiwdkDjNAvPvOLUBJak7jnJ4KVUkWf3MDzu30BUOO3sy1GS9oiacPiDcedWknLTTfPfTf83k/z0fnawxWdt+mRX86tdR+wV3HmGZrw61It5PH9DRP7+Ux7mdbU/texC/G9OHAo9kf04KahC8elq/g+o1rYcfqiyUWnFkAokPIdoMFc83f3/CaZNfss67mFWyjBvajTWTxyTsVuy0319ydAFXjaifGZud72x1krUcAN5ZHJsXykmynnOzv9sed79fosVnrziKxb8/LRKvEk/fe5VNvcxhgm3XPJefH9cjsFOPlzaot096m3RZ70sPKRqYRGpIKNH87SdDAPjXJUcm1N4d+XugsSiBBelU8OrVx0QUcbwSoXVN/87hqPmmuXWfpSDZmYU9YPFLfe6XoiMnK4OmuVkR81W8OtpedbOda0MVCSZzjLfI7Zcm3SvavSE4sH/BSdDwk7z9izMGdmLN5DExqdb9iJdgbX/GDpzrk6KUI0F0bZPviEmov6f4pSuP5pbTe0c8oeqSZD387PULd9I9O2V+p5bxPdXsDL/udSLnSL9t01iPKqdpKtkcU27OHtLZN02LuwBTQ6HeUEq9UBc+5unI8Ye1Z/rqbbSsQQbcusJeO6lR1cQakpedyYTja2byuvSYgriOEcnmyLIr1bnLtX746xNiMtd6cUKv9vz6lMP42fACAKZddxz/+WpNJAV+eagqKkmhzYm9O/D3j1fFbA/inCGdo0q4Avy4qAurN+9hfnF4hpqTmRGZKaVDSh/QmQWg3lD1gW13DRrl7W9EvKAa8CHq2b4ZayaPiVpwT2fiZaqF+DmlvLA7crcZTkQCFQWEzUm/PLlXROH37dSCyecOREQQEU9FAeEEh7Y5dmiBd1JHL7xmY8bAlQ4Pwd4HN4/alw4kNLMQkZ5AsTGmTERGAAOB/xhjUlNMoQFIA2eDA5rMDOGv44dEPFAOFCJ2bn1+EuZdj8JHTpI1Q9kzi7IUlQSIRxsr71sy+s1rptC2WY5nOhCIv5ZSnyT6EV8GQiJyKPAvoDvwTMqkUg5IfjSoU1I+/PsDdgDbyD4NHzS1vxCUQr15kvEjdlBfaT0u8Ns0t9bs2jVLPErcHaB6ydEF9O7YImpmWO74LPVYOTUuid6VKmNMpYicDTxojPmriHydSsHqkzRR3Mp+iJ1OXQnz/ISjoio5ehGUJyyZCHSoVj4VlfX/Q+7fuQV/OGcAZ7gqCMbDWXr1mSuGMdyhJMYP7cqzM9dGzSzSpX9KVFlUiMh4wllhf2RtOzCc5S3SIehFUfZ3/NKpO4kXR/H29ckXxRzWPXzNE+o5AzOE+414pWW9yMrM4N7zBtK2aU6k8qJN0SFteHbm2qjyraE6CvisLYkqi0uBK4FJxphvRaQ78N/UiaUoyoHK6P4dmeMTSOeVAj+IAV1asnLS6P0qDf75PjU1bBfzrXvLI9uCSrnWFwl9u8aYJcaY64wxz4pIa6C5MWZyimWrN4z6QylKveGX5+iYQ9smHLfjZn9SFPFYvyOcdbissiridBNUi76+SOgbFpGPRaSFiLQB5gNTROT+1IpWv6gRSlHqB7tmh5t7zxuU9HrFgcbS9dVpY+xqgSf17tBQ4kSRqDpuaYzZBZwDTDHGHAGMTJ1YiqIcqPitDx6ogZvJ4IzBKGibz7zbT+HyY+s+Sr4mJKosskTkYOB84KiDBbIAABInSURBVI0UyqMoSiOlIQr6pBt9O1WnjcnMEFrl56SN802id+cuwrW0vzDGzBKRHsCK1IlVv6SLa5qiNDYGdmlJtzb5LPxhZ2Bkd2PAObtauWlPA0oSS0LKwhjzIvCi4/1q4NxUCdUgpIfyVpRGwcXDD+Gwjs25cNghDS1KWiEiZGcKFSHDqhqkf08liab76AL8FTiGcBacz4FfGWNql2pRUZRGye/H9m9oEdIWZ0BeOpHomsUUYCrQCegM/M/adkCQnrdGURQlfUhUWbQ3xkwxxlRaf08C9R8umULquoayoijKgUSiymKLiFwkIpnW30XA1lQKpiiKoqQPiSqLywi7zW4A1gPnEU4BcmCgdihFUdKM8UO9U4I0FImm+/jeGHOmMaa9MaaDMeYswgF6Bwxp4sqsKIoCwEVHpZenWG0SqtwQ1EBERonIMhFZKSITPfZfKSILRWSeiHwuIn0d+262jlsmIqfVQk5FUZT9jk4t06v2S22URdyxuIhkAg8Do4G+wHinMrB4xhgzwBgzGLgXuN86ti8wDugHjAL+bp0vJWgiQUVR0o1ESsLWJ7VRFkE97FBgpTFmtTGmHHgOGBt1gnC+KZumjnOOBZ4zxpQZY74FVlrnSxlqhVIUJZ3I9Si/2pDEDcoTkd14KwUBguZInYG1jvfFwDCPa1xD2KSVA5zkOHa669jOHsdOACYAdOuWXAESRVGUdCbdMvDGVRbGmOa1OLfXJ41RPMaYh4GHReQnwO8IV+NL9NjHgMcAioqKamxL0txQiqKkC7ef0ZfvtqZXqg9IPJFgTSgGnL5fXYB1cdo/BzxSw2NrjXpDKYqSDlyWJinJ3aTSKDYL6CUi3UUkh/CC9VRnAxHp5Xg7hupMtlOBcSKSa5Vw7QXMTKGsiqIoShxSNrMwxlSKyLWEU5tnAk8YYxaLyF3AbGPMVOBaERkJVADbCZugsNq9ACwBKoFrjDGhVMmqKIqixCel1UaMMdOAaa5ttzte/yrOsZOASamTznGt+riIoijKfkx6+WY1IJpIUFEUxR9VFoqiKEogqiwAo76ziqIocVFlYaGus4qiKP6oslAURVECUWWBekMpiqIEocrCQq1QiqIo/qiyUBRFUQJRZYEmElQURQlClYWNukMpiqL4ospCURRFCUSVhaIoihKIKgsLNUIpiqL4o8pCURRFCUSVhaIoihJIo1cWmkRQURQlmEavLGzUc1ZRFMUfVRaKoihKII1eWagVSlEUJZhGryxstKyqoiiKP6osFEVRlEAavbJQK5SiKEowjV5Z2Kg3lKIoij+qLBRFUZRAGr2y0KA8RVGUYFKqLERklIgsE5GVIjLRY/8NIrJERBaIyAcicohjX0hE5ll/U1MpJ2giQUVRlHhkperEIpIJPAycAhQDs0RkqjFmiaPZ10CRMWafiFwF3AtcYO0rMcYMTpV8iqIoSuKkcmYxFFhpjFltjCkHngPGOhsYYz4yxuyz3k4HuqRQHkVRFKWGpFJZdAbWOt4XW9v8uBx4y/E+T0Rmi8h0ETkrFQKCus4qiqIkQsrMUHgvA3j2zSJyEVAEnODY3M0Ys05EegAfishCY8wq13ETgAkA3bp1q52wumihKIriSypnFsVAV8f7LsA6dyMRGQncCpxpjCmztxtj1ln/VwMfA0PcxxpjHjPGFBljitq3b1+30iuKoigRUqksZgG9RKS7iOQA44AoryYRGQL8g7Ci2OTY3lpEcq3X7YBjAOfCeJ2hnrOKoijBpMwMZYypFJFrgXeATOAJY8xiEbkLmG2MmQrcBzQDXpSwHeh7Y8yZQB/gHyJSRVihTXZ5UdU5onYoRVEUX1K5ZoExZhowzbXtdsfrkT7HfQkMSKVsiqIoSuJoBLf6QymKogTS6JWFoiiKEowqC0VRFCWQRq8s1BtKURQlmEavLGzUGUpRFMUfVRaKoihKIKosFEVRlEBUWViIVrRQFEXxRZWFoiiKEogqC0VRFCWQRq8s1HVWURQlmEavLGzUdVZRFMUfVRaKoihKII1eWWgiQUVRlGAavbKwUSuUoiiKP6osFEVRlEAavbJQbyhFUZRgGr2ysFFvKEVRFH9UWSiKoiiBNHploVYoRVGUYBq9srDRRIKKoij+qLJQFEVRAmn0ysKoO5SiKEogjV5Z2Kg3lKIoij+qLBRFUZRAVFkoiqIogaRUWYjIKBFZJiIrRWSix/4bRGSJiCwQkQ9E5BDHvotFZIX1d3GqZNQVC0VRlGBSpixEJBN4GBgN9AXGi0hfV7OvgSJjzEDgJeBe69g2wB3AMGAocIeItE6VrIqiKEp8UjmzGAqsNMasNsaUA88BY50NjDEfGWP2WW+nA12s16cB7xljthljtgPvAaNSKKuiKIoSh1Qqi87AWsf7YmubH5cDbyVzrIhMEJHZIjJ78+bNNRJSPWcVRVGCSaWy8HJG9eyaReQioAi4L5ljjTGPGWOKjDFF7du3r7Gglgy1Ol5RFOVAJpXKohjo6njfBVjnbiQiI4FbgTONMWXJHKsoiqLUD6lUFrOAXiLSXURygHHAVGcDERkC/IOwotjk2PUOcKqItLYWtk+1ttU9aoZSFEUJJCtVJzbGVIrItYQ7+UzgCWPMYhG5C5htjJlK2OzUDHjRMgN9b4w50xizTUTuJqxwAO4yxmxLlaygZVUVRVHikTJlAWCMmQZMc2273fF6ZJxjnwCeSJ10iqIoSqI0+ghuo3YoRVGUQBq9srBRZyhFURR/VFkoiqIogaiyUBRFUQJp9MpCI7gVRVGCafTKwkaXLBRFUfxRZaEoiqIE0uiVhVqhFEVRgmn0ysJGEwkqiqL4o8pCURRFCaTRKwuj7lCKoiiBNHplYaNWKEVRFH9UWSiKoiiBNHplkZOVwZgBB9OtTX5Di6IoipK2pDRF+f5A87xsHr6wsKHFUBRFSWsa/cxCURRFCUaVhaIoihKIKgtFURQlEFUWiqIoSiCqLBRFUZRAVFkoiqIogaiyUBRFUQJRZaEoiqIEIgdKIj0R2Qx8V4tTtAO21JE4qWJ/kBH2Dzn3BxlB5axL9gcZof7lPMQY0z6o0QGjLGqLiMw2xhQ1tBzx2B9khP1Dzv1BRlA565L9QUZIXznVDKUoiqIEospCURRFCUSVRTWPNbQACbA/yAj7h5z7g4ygctYl+4OMkKZy6pqFoiiKEojOLBRFUZRAGr2yEJFRIrJMRFaKyMQGuP4TIrJJRBY5trURkfdEZIX1v7W1XUTkIUvWBSJS6DjmYqv9ChG5uI5l7CoiH4nIUhFZLCK/SlM580RkpojMt+T8vbW9u4jMsK75vIjkWNtzrfcrrf0FjnPdbG1fJiKn1aWc1vkzReRrEXkjjWVcIyILRWSeiMy2tqXVPbfO30pEXhKRb6xndHg6ySkih1vfof23S0SuTycZE8IY02j/gExgFdADyAHmA33rWYbjgUJgkWPbvcBE6/VE4I/W69OBtwABjgJmWNvbAKut/62t163rUMaDgULrdXNgOdA3DeUUoJn1OhuYYV3/BWCctf1R4Crr9dXAo9brccDz1uu+1rOQC3S3npHMOr7vNwDPAG9Y79NRxjVAO9e2tLrn1jX+Dfzcep0DtEpHOa3rZAIbgEPSVUZf2evrQun4BwwH3nG8vxm4uQHkKCBaWSwDDrZeHwwss17/AxjvbgeMB/7h2B7VLgXyvg6cks5yAvnAXGAY4QCnLPc9B94Bhluvs6x24n4OnO3qSLYuwAfAScAb1jXTSkbrnGuIVRZpdc+BFsC3WOuv6Sqn47ynAl+ks4x+f43dDNUZWOt4X2xta2gOMsasB7D+d7C2+8lbb5/DMoMMITxqTzs5LfPOPGAT8B7hEfcOY0ylxzUj8lj7dwJt60HOB4HfAlXW+7ZpKCOAAd4VkTkiMsHalm73vAewGZhimfX+KSJN01BOm3HAs9brdJXRk8auLMRjWzq7h/nJWy+fQ0SaAS8D1xtjdsVr6iNPyuU0xoSMMYMJj96HAn3iXLPe5RSRM4BNxpg5zs1xrteQ9/wYY0whMBq4RkSOj9O2oeTMImzGfcQYMwTYS9ik40eDfZ/WOtSZwItBTX1kadD+qrEri2Kgq+N9F2BdA8niZKOIHAxg/d9kbfeTN+WfQ0SyCSuKp40xr6SrnDbGmB3Ax4Rtvq1EJMvjmhF5rP0tgW0plvMY4EwRWQM8R9gU9WCayQiAMWad9X8T8Cph5Ztu97wYKDbGzLDev0RYeaSbnBBWunONMRut9+kooy+NXVnMAnpZnig5hKeIUxtYJgjLYHs6XEx4jcDe/jPLW+IoYKc1fX0HOFVEWlseFada2+oEERHgX8BSY8z9aSxnexFpZb1uAowElgIfAef5yGnLfx7woQkbg6cC4yxPpO5AL2BmXchojLnZGNPFGFNA+Hn70BhzYTrJCCAiTUWkuf2a8L1aRJrdc2PMBmCtiBxubToZWJJuclqMp9oEZcuSbjL6U1+LI+n6R9jzYDlh2/atDXD9Z4H1QAXhkcPlhG3SHwArrP9trLYCPGzJuhAocpznMmCl9XdpHct4LOHp7gJgnvV3ehrKORD42pJzEXC7tb0H4Y50JWETQK61Pc96v9La38Nxrlst+ZcBo1N070dQ7Q2VVjJa8sy3/hbbv410u+fW+QcDs637/hphT6G0kpOww8VWoKVjW1rJGPSnEdyKoihKII3dDKUoiqIkgCoLRVEUJRBVFoqiKEogqiwURVGUQFRZKIqiKIGoslD2K0QkZGXunC8ic0Xk6ID2rUTk6gTO+7GIpF3d44ZERJ4UkfOCWyqNAVUWyv5GiTFmsDFmEOFken8IaN+KcObWtMQRta0oaY0qC2V/pgWwHcJ5q0TkA2u2sVBExlptJgM9rdnIfVbb31pt5ovIZMf5fizhehjLReQ4q22miNwnIrOs2gK/sLYfLCKfWuddZLd3IuF6EH+0zjlTRA61tj8pIveLyEfAHyVc1+A16/zTRWSg4zNNsWRdICLnWttPFZGvrM/6ooRzdiEik0VkidX2T9a2H1vyzReRTwM+k4jI36xzvEl1YjtFQUc1yv5GEwlnlc0jnLb5JGt7KXC2MWaXiLQDpovIVMJJ5fqbcHJBRGQ0cBYwzBizT0TaOM6dZYwZKiKnA3cQThdyOeF0C0eKSC7whYi8C5xDOI34JBHJJByh68Uu65w/I5wD6gxr+2HASGNMSET+CnxtjDlLRE4C/kM4Kvk269oD/n979/JqYxSHcfz7jEhKkmQgA7kk5BaJhJSBkQwcKWREUSgpSZRMDEwYESKdolwiQhSlQy4JA/8AA9dyDR0/g9/aeWO/XiXpOM9nsnd7n7X3b+3d2etda9WzSu0DS9+2lrbvJW0GNkraCywCxkREtGJPgG3Agoh4Unmsrk+TgNHAeGAIGZtx8Le+FfvvebCwnuZj5Yd/BnBE0jgyImGXMhn1KxndPKRN+/nAoYj4ABARryrPtQIS75JnjEDm70yorN0PIHOYbgMHlQGLpyPifk29nZXbPZXHT0REd7k/C1hc6rkqaZCkAaXWjlaDiHitTK0dS/7AQx720wW8IQfMA2VWcK40uwEclnS80r+6Ps0GOktdTyVdremT9UIeLKzHioiucqU9mMyqGgxMiYgvylTXvm2aifpY50/ltpvv/xsC1kXET4FtZWBaCByVtDsijrQrs+b++x9qateuXa0CLkfE0jb1TCOD9DqAtcC8iFgtaXqp876kiXV9KjMq5/9YW96zsB5L0hjymMqX5NXxszJQzCWPrQR4Sx4F23IJWCWpX3mN6jJUOxeBNWUGgaRRykTW4eX99pOJvJNr2i+p3HbV/M11YFl5/TnAi8jzQi6RP/qt/g4EbgIzK/sf/UpN/cmQuvPAenIZC0kjIuJWRGwjT9kbVtenUkdH2dMYCsxt+GysF/HMwnqa1p4F5BXyirLufww4K+kOmYr7GCAiXkq6IekRcCEiNpWr6zuSPgPngS2/eL8D5JLUPeW6z3Nyz2MOsEnSF+AdsLymfR9Jt8gLs59mA8V28qS3B8AHvsdW7wT2ldq7gR0RcVLSSqCz7DdA7mG8Bc5I6ls+lw3lud2SRpbHrpApsg9q+nSK3AN6SCYxX/vF52K9jFNnzf6SshQ2NSJe/OtazP6Ul6HMzKyRZxZmZtbIMwszM2vkwcLMzBp5sDAzs0YeLMzMrJEHCzMza+TBwszMGn0Du+MWaz+J9zgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "learn.recorder.plot_losses()\n",
    "learn.recorder.plot_metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-09-02T17:01:01.524632Z",
     "start_time": "2019-09-02T17:00:55.526160Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reload efficientnet-b5_0902_04-26-49_stage1\n"
     ]
    }
   ],
   "source": [
    "learn.load(model_save_name)\n",
    "print(\"Reload\", model_save_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn = Learner(data_2019, \n",
    "                model, \n",
    "                metrics = [qk],\n",
    "                callback_fns=[partial(EarlyStoppingCallback, min_delta=0, patience=3)],\n",
    "                model_dir = '../output/models/')\n",
    "\n",
    "learn.data.add_test(ImageList.from_df(test_df,\n",
    "                                      '../input/aptos2019-blindness-detection',\n",
    "                                      folder='test_images_ben_preprocessing_sigmaX10',\n",
    "                                      suffix='.png'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.load(model_save_name)\n",
    "\n",
    "# Explore lr from `start_lr` to `end_lr` over `num_it` iterations in `learn`. If `stop_div`, stops when loss diverges.\n",
    "learn.lr_find() \n",
    "learn.recorder.plot(suggestion=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_save_name = \"{}_{}_stage2\".format(model_name, current_time)\n",
    "# min_grad_lr = learn.recorder.min_grad_lr\n",
    "learn.fit_one_cycle(40, 1e-5, callbacks=[SaveModelCallback(learn, every='improvement', name=model_save_name)])\n",
    "print(\"Model save as:\", model_save_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.recorder.plot_losses()\n",
    "learn.recorder.plot_metrics()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "learn.load(model_save_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Optimize the Metric\n",
    "Optimizing the quadratic kappa metric was an important part of the top solutions in the previous competition. Thankfully, @abhishek has already provided code to do this for us. We will use this to improve the score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import scipy as sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OptimizedRounder(object):\n",
    "    \"\"\"\n",
    "    Optimize threshold coefficients.\n",
    "    \"\"\"\n",
    "    def __init__(self):\n",
    "        self.coef_ = 0\n",
    "\n",
    "    def _kappa_loss(self, coef, X, y):\n",
    "        \"\"\"\n",
    "        Customized loss function.\n",
    "        \n",
    "        :param coef: list, shape=[4]\n",
    "            Threshold.\n",
    "        :param X: list, shape=[5]\n",
    "            Prediction.\n",
    "        :param y: list, shape=[5]\n",
    "            Golden label.\n",
    "        \"\"\"\n",
    "        X_p = np.copy(X)\n",
    "        for i, pred in enumerate(X_p):\n",
    "            if pred < coef[0]:\n",
    "                X_p[i] = 0\n",
    "            elif pred >= coef[0] and pred < coef[1]:\n",
    "                X_p[i] = 1\n",
    "            elif pred >= coef[1] and pred < coef[2]:\n",
    "                X_p[i] = 2\n",
    "            elif pred >= coef[2] and pred < coef[3]:\n",
    "                X_p[i] = 3\n",
    "            else:\n",
    "                X_p[i] = 4\n",
    "        \n",
    "        # Cohen's kappa: a statistic that measures inter-annotator agreement.\n",
    "        ll = metrics.cohen_kappa_score(y, X_p, weights='quadratic')\n",
    "        return -ll\n",
    "\n",
    "    def fit(self, X, y):\n",
    "        \"\"\"\n",
    "        :param X: list, shape=[5]\n",
    "            Prediction.\n",
    "        :param y: list, shape=[5]\n",
    "            Golden label.\n",
    "        \"\"\"\n",
    "        # new function with partial application of the given arguments and keywords.\n",
    "        loss_partial = partial(self._kappa_loss, X=X, y=y)\n",
    "        initial_coef = [0.5, 1.5, 2.5, 3.5]\n",
    "        # Minimization of scalar function of one or more variables.\n",
    "        self.coef_ = sp.optimize.minimize(loss_partial, initial_coef, method='nelder-mead')\n",
    "        print(-loss_partial(self.coef_['x']))\n",
    "\n",
    "    def predict(self, X, coef):\n",
    "        \"\"\"\n",
    "        :param X: list, shape=[5]\n",
    "            Prediction.\n",
    "        :param coef: list, shape=[4]\n",
    "            Threshold.\n",
    "        \"\"\"\n",
    "        X_p = np.copy(X)\n",
    "        for i, pred in enumerate(X_p):\n",
    "            if pred < coef[0]:\n",
    "                X_p[i] = 0\n",
    "            elif pred >= coef[0] and pred < coef[1]:\n",
    "                X_p[i] = 1\n",
    "            elif pred >= coef[1] and pred < coef[2]:\n",
    "                X_p[i] = 2\n",
    "            elif pred >= coef[2] and pred < coef[3]:\n",
    "                X_p[i] = 3\n",
    "            else:\n",
    "                X_p[i] = 4\n",
    "        return X_p\n",
    "\n",
    "    def coefficients(self):\n",
    "        return self.coef_['x']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Return predictions and targets on `ds_type` dataset.\n",
    "valid_preds = learn.get_preds(ds_type=DatasetType.Valid)\n",
    "optR = OptimizedRounder()\n",
    "optR.fit(valid_preds[0],valid_preds[1])\n",
    "coefficients = optR.coefficients()\n",
    "print(coefficients)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Error Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_pred = optR.predict(valid_preds[0], [0.5, 1.5, 2.5, 3.5])\n",
    "cm = confusion_matrix(valid_pred,valid_preds[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot_confusion_matrix(cm, classes=range(5), normalize=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "learn.show_results()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Submission"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds,y = learn.get_preds(DatasetType.Test)\n",
    "tst_pred = optR.predict(preds, coefficients)\n",
    "test_df.diagnosis = tst_pred.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_filename = '{}_submition.csv'.format(model_save_name)\n",
    "test_df.to_csv(save_filename,index=False)\n",
    "print (save_filename, 'done')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df.hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df.diagnosis = optR.predict(preds, [0.5, 1.5, 2.5, 3.5])\n",
    "test_df.hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.read_csv(\"0.806.csv\").hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
